package com.xiaoyu.net.proto.gen.proto.demo;

import static com.xiaoyu.net.proto.gen.B2G.CLIENT;
import static com.xiaoyu.net.proto.gen.B2G.DATA;
import static com.xiaoyu.net.proto.gen.B2G.SERVER;

import java.util.List;
import java.util.Map;

import com.xiaoyu.io.FileEx;
import com.xiaoyu.net.proto.gen.B2Class;
import com.xiaoyu.net.proto.gen.B2Field;
import com.xiaoyu.net.proto.gen.B2Method;
import com.xiaoyu.net.proto.gen.B2Param;
import com.xiaoyu.net.proto.gen.Bio2GCSharp;
import com.xiaoyu.net.proto.gen.Bio2GJava;

@B2Class(namespace = "ocean")
public class OceanG {
	@B2Class(type = DATA, remark = "Global" , constant = true)
	class Global {
		@B2Field(def = "123", remark= "val1")
		public int TYPE_D1;
		@B2Field(def = "456", remark= "val2")
		public int TYPE_D2;
		@B2Field(def = "222", remark= "val3")
		public int TYPE_D3;

		@B2Field(def = "d1", remark= "d1")
		public String STR_D1;
		@B2Field(def = "d2", remark= "d2")
		public String STR_D2;
	}

	// ///////////////////////////////////////////////////
	@B2Class(type = DATA, remark = "out boolVal")
	class OutBoolVal {
		public boolean val;
	}

	@B2Class(type = DATA, remark = "out intVal")
	class OutIntVal {
		public int val;
	}

	@B2Class(type = DATA, remark = "out longVal")
	class OutLongVal {
		public long val;
	}

	@B2Class(type = DATA, remark = "out stringVal")
	class OutStrVal {
		public String val;
	}

	@B2Class(type = DATA, remark = "out bytesVal")
	class OutBytesVal {
		public byte[] val;
	}

	@B2Class(type = DATA, remark = "out stringListVal")
	class OutStrListVal {
		public List<String> val;
	}

	@B2Class(type = DATA, remark = "out doubleVal")
	class OutDoubleVal {
		public double val;
	}

	// ///////////////////////////////////////////////////

	@B2Class(type = DATA, remark = "����ֵ")
	class ReturnStatus {
		public int succ;
		public String msg;
	}

	@B2Class(type = DATA, remark = "��ͷ��Ϣ")
	class Dock {
		public int id;
		public String name;
		public int txid;
		public int userId;
		public String userMz;
		public int userLvl;
		public String unionMz;
		public int portId;
		public int y;
		public int strong;
		public boolean protect;
	}

	@B2Class(type = DATA, remark = "������ʾ")
	class TipItem {
		public int type;
		public String text;
		public int value;
	}

	@B2Class(type = DATA, remark = "���а�")
	class BillItem {
		public int id;
		public int oid;
		public String s1;
		public String s2;
		public String s3;
	}

	@B2Class(type = DATA, remark = "������ͷ���")
	class PirateDockItem {
		public int id;
		public String mz;
		public int lvl;
		public int iconId; // ͷ��id
		public boolean isFinish;
		public boolean isCurrent;
		public boolean isBoss;
		public int power; // ս����
		public int captionNum; // ������
		public int tonnage; // ��λ
		public String skills;
		public String formation;
		public String str; // ����
		public int stroy1;
		public int stroy2;
		public int star; // �ɾ�(����)
		public List<PirateDockReward> rewards;
		public List<PirateCaptionPos> captionPostion; // ��������λ��
	}

	@B2Class(type = DATA, remark = "������ͷ����")
	class PirateDockReward {
		public int id;
		public int type; // 0:���� 1:װ��
		public int quality; // Ʒ��
		public int lvl;
		public String str;
	}

	@B2Class(type = DATA, remark = "������ͷ����λ��")
	class PirateCaptionPos {
		public int ccid;
		public int x;
		public int y;
	}

	@B2Class(type = DATA, remark = "25PP��ֵ����")
	class OrderItem25PP {
		public int id;
		public double rmb;
		public int gold;
		public String dat;
		public int stat; // -1:ʧ�� 0:�ȴ��� 1:�ɹ�
	}

	@B2Class(type = DATA, remark = "�ۿ�״̬")
	class PortStatItem {
		public int id;
		public boolean isOpen; // �Ƿ񿪷�
		public boolean isFire; // �Ƿ�ս��
		public boolean isSomebody; // �Ƿ�����
	}

	@B2Class(type = DATA, remark = "װ����Ϣ")
	public class EquipItem {
		public int id;
		public String icon;
		public String mz; // ����
		public int lv; // �ȼ�
		public int captainId; // ����id
		public int bodyId; // ����λ��
		public Map<String, Integer> attr; // ����
		public int strongNum; // ǿ������
		public int quality; // 1:��ɫ,2:��ɫ,3:��ɫ,4:��ɫ
		public int sliver; // ����
		public boolean isDelete; // �Ƿ�ɾ��
	}

	@B2Class(type = DATA, remark = "������Ϣ")
	public class PropItem {
		public int id;
		public String mz; // ����
		public int quality; // Ʒ��
		public int type;
		public int num;
		public String str; // ����
		public String effect; // Ч��
		public int userDjid; // �û��ĵ���id
		public int icon;
	}

	@B2Class(type = DATA, remark = "�ʼ���Ϣ")
	public class MailItem {
		public int id;
		public int type;
		public int senderId; // ������
		public String senderMz;
		public int receiverId; // ������
		public String receiverMz;
		public String title;
		public String content;
		public String dat;
		public boolean readed;

		public boolean isPvp;
		public int yhid;
		public String yhmz;
		public int portId;
		public String portMz;
		public int dockId;
		public String dockMz;
	}

	@B2Class(type = DATA, remark = "�ʼ��嵥")
	public class Mails {
		List<MailItem> mails;
	}

	@B2Class(type = DATA, remark = "����")
	public class MsgItem {
		int type; // 1:���� 2:���� 3:˽�� 4:������
		int uid;
		String mz;
		String mz2;
		String msg;
		long tm;
	}

	@B2Class(type = DATA, remark = "������Ϣ")
	public class UnionItem {
		public int id;
		public String name; // ����
		public String shortName; // ������
		public int lvl; // ����ȼ�
		public int gold; // ������
		public int member; // ��Ա����
		public int memberMax; // ����Ա��
		public String desc; // �������
		public int leaderId; // �᳤id
		public String leader; // �᳤����
	}

	@B2Class(type = DATA, remark = "������Ϣ")
	public class Unions {
		public List<UnionItem> unions;
	}

	@B2Class(type = DATA, remark = "�����Ա")
	public class UnionMember {
		public int id;
		public String name; // ����
		public long score; // ����
		public String title; // ְλ
		public String dat; // ����¼
		public boolean online;
		public int donationGold; // ļ����
	}

	@B2Class(type = DATA, remark = "�����Ա")
	public class UnionMembers {
		public List<UnionMember> members;
	}

	@B2Class(type = DATA, remark = "�������")
	public class UnionReq {
		public int id;
		public String name;
		public int score;
		public String dat;
	}

	@B2Class(type = DATA, remark = "�������")
	public class UnionReqs {
		public List<UnionReq> reqs;
	}

	@B2Class(type = DATA, remark = "���Ὠ��")
	public class UnionBuilding {
		public int id;
		public String name;
		public int lvl;
		public int nextGold;
		public String desc;
	}

	@B2Class(type = DATA, remark = "���Ὠ��")
	public class UnionBuildings {
		public List<UnionBuilding> buildings;
	}

	@B2Class(type = DATA, remark = "ID MZ")
	public class IdMzItem {
		public int id;
		public String mz;
	}

	@B2Class(type = DATA, remark = "ID MZ s")
	public class IdMzItems {
		public List<IdMzItem> items;
	}

	@B2Class(type = DATA, remark = "������Ϣ")
	public class VoyageItem {
		public int captainId;
		public String captainMz;
		public int lvl;
		public int tonnage; // ��λ
		public int type; // 1:�ҵĺ��� 2:���ѵĺ��� 3:���˵ĺ���

		public int routeId; // ����id
		public String departureTime; // ����ʱ��
		public String arriveTime; // ����ʱ��

		public int yhid1;
		public String yhmz1;
		public int mtid1;
		public String mtmz1;

		public int yhid2;
		public String yhmz2;
		public int mtid2;
		public String mtmz2;

		public int cmd;
		public int state; // 1.�ȴ���ʼ 2:ǰ�� 3:ͣ���� 4:ս���� 5.������ 6.����
		public int fightId;
	}

	@B2Class(type = DATA, remark = "��Ʒ")
	public class MarketItem {
		public int id;
		public String mz;
		public String str;
		public int gold;
		public int icon;
		public double discount;
	}

	@B2Class(type = DATA, remark = "��Ʒ�嵥")
	public class MarketItems {
		public List<MarketItem> items;
	}

	@B2Class(type = DATA, remark = "�ղؼ�")
	public class FavoriteItem {
		public int dockId;
		public String dockMz;
		public int yhid;
		public String yhmz;
		public int type;// 0:��ͨ,���� 1:����
		public int portId;
		public String portMz;
		public boolean isDelete = false;
	}

	@B2Class(type = DATA, remark = "����")
	public class SkillItem {
		public int id; // ����id
		public int lvl;
		public int exp;
		public int nextExp;
	}

	@B2Class(type = DATA, remark = "����")
	public class FormationItem {
		public int id; // ����id
		public int lvl;
		public int exp;
		public int nextExp;
	}

	@B2Class(type = DATA, remark = "��λ��Ϣ")
	public class MarineItem {
		public int id;
		public int pos;
		public int tonnage;
		public int num;
	}

	@B2Class(type = DATA, remark = "������Ϣ��Ϣ")
	public class Marine {
		public int tonnage; // ��λ
		public int maxTonnage; // �ܶ�λ
		public List<MarineItem> items; // ��λ��Ϣ
	}

	@B2Class(type = DATA, remark = "������Ϣ")
	public class CaptainItem {
		public int id;
		public String mz;
		public int yhid;
		public String yhmz;
		public int jobId;
		public int type;
		public int lvl;
		public long exp;
		public long nextExp;
		public int icon; // ͷ��
		public Map<String, Integer> ability; // ������:����ֵ
		public Map<String, Integer> ability2; // �������� ������:����ֵ
		public String mainAttr; // ������
		public String auxAttr1; // ������1
		public String auxAttr2; // ������2
		public SkillItem mainSkill; // ������
		public SkillItem auxSkill; // ������
		public FormationItem formation; // ����
		public Map<Integer, Integer> equips; // װ��
		public Marine marine; // ����
		public List<Integer> gains; // ��������
		public boolean autoFill;
		public boolean isDelete;

		public boolean isTraining; // �Ƿ�ѵ��
		public int trainingGem; // ѵ������
		public String traningEndTm = ""; // ѵ������ʱ��
		public int acqGemIncome; // ���βɼ�����
		public long acqGemEndTm; // �ɼ���ȴʱ��
		public int forceAcqGold; // ǿ�Ʋɼ�����
		public int stat; // ����״̬
		public int dockId; // ������ͷid
		public boolean isDef; // Ĭ�Ͻ���
		public int potential; // Ǳ��ֵ
	}

	@B2Class(type = DATA, remark = "�������齱��")
	public class CaptainExpReward {
		public int id;
		public String mz;
		public int exp;
	}

	@B2Class(type = DATA, remark = "����ս������")
	public class PirateReward {
		public int silver; // ����
		public int honor; // ����
		public String props; // ����
		public String equips; // װ��
		public List<CaptainExpReward> captainExps; // �������齱��
		public String autoReplenishment; // �Զ�����
	}

	@B2Class(type = DATA, remark = "VIP��Ϣ")
	public class VipItem {
		public int id;
		public int gold; // ���
		public String str; // ����
	}

	@B2Class(type = DATA, remark = "VIPs��Ϣ")
	public class VipItems {
		public List<VipItem> items;
	}

	@B2Class(type = DATA, remark = "ս����λ��Ϣ")
	public class XBerth {
		public int pos; // λ��
		public int jcid; // ����
		public int num; // ����
		public double durable2; // ��ǰ�;�
	}

	@B2Class(type = DATA, remark = "ս��������Ϣ")
	public class XFleet {
		public int id;
		public String mz;
		public int lvl;
		public int icon; // ͷ��
		public int yhid;
		public String yhmz;
		public int ts; // ͳ˧
		public int ld; // �Ӷ�
		public int zc; // ���
		public int js; // ��ʻ
		public int gj; // ����
		public int fy; // ����
		public int x;
		public int y;

		public double tech_strong; // ����ӹ�ѧ
		public double tech_gunpowder; // ��ҩѧ

		public SkillItem mainSkill; // ������
		public SkillItem auxSkill; // ������
		public FormationItem formation; // ����

		public double attackGain; // ��������
		public double defenseGain; // ��������
		public double skillGain; // ��������
		public double formationGain; // ����

		public List<XBerth> berths; // ����

		public int campId; // ��Ӫid
		public boolean isPirate; // �Ƿ񺣵�
	}

	@B2Class(type = DATA, remark = "������������")
	public class RenewAttr {
		public int ts;// "ͳ˧"
		public int gj; // "����"
		public int fy; // "����"
		public int ld; // "�Ӷ�"
		public int js; // "��ʻ"
		public int zc; // "���";
	}

	@B2Class(type = DATA, remark = "�һ���Ҽ۸�")
	public class ExchangeGoldItem {
		public int id;
		public String mz;
		public int val;
	}

	@B2Class(type = DATA, remark = "�һ���Ҽ۸�")
	public class ExchangeGoldItems {
		public List<ExchangeGoldItem> items;
	}

	@B2Class(type = DATA, remark = "ս��Ѱ��")
	public class FightPvpTargert {
		public int uid;
		public int icon;
		public String userMz;
		public int lvl;
		public String unionMz;
		public int knighthoodId;
		public String knighthood;
		public int strong;
		public int portId;
		public int dockId;
		public String dockMz;
		public long dockSilver;
		public int paySilver; // Ѱ�л�������
	}

	@B2Class(type = DATA, remark = "ƻ���̳ǹ����Ҽ۸�")
	public class AppleItem {
		public int id;
		public String aid; // ƻ����Ʒ����
		public double money; // ��Ԫ
		public int gold; // �һ����
		public int gift; // ���ͽ��
	}

	@B2Class(type = DATA, remark = "�û�������Ϣ")
	public class BaseUserInfo {
		public int uid;
		public int icon;
		public String userMz;
		public int lvl;
		public int ranking; // ����
		public String unionMz; // ��������
		public String unionTitle; // ����ְλ
		public int knighthoodId; // ��λid
		public String knighthood;
	}

	// //////////////////////

	@B2Class(type = SERVER)
	interface OceanI {
		// //////////////////////////////////////////////////////////////////
		// ��������ʵ��
		@B2Method(type = SERVER, params = { "s" }, remark = "ping")
		ReturnStatus ping(String s);

		@B2Method(type = SERVER, params = { "uuid", "sex", "outReged", "outMz" }, remark = "��ȡ�û���")
		ReturnStatus getNewUserName(
				String uuid,
				int sex,
				@B2Param(oType = "OutBoolVal", isOut = true) OutBoolVal outReged,
				@B2Param(oType = "OutStrVal", isOut = true) OutStrVal outMz);

		@B2Method(type = SERVER, params = { "nick", "portId", "jobId",
				"headId", "uuid", "dvid", "token", "phone", "screen", "chnId",
				"ver", "outDat" }, remark = "ע��")
		ReturnStatus register(String nick, int portId, int jobId, int headId,
				String uuid, String dvid, String token, String phone,
				String screen, String chnId, double ver,
				@B2Param(oType = "OutStringVal", isOut = true) OutStrVal outDat);

		@B2Method(type = SERVER, params = { "uuid", "dvid", "token", "phone",
				"screen", "ver", "outDat", "outHasPvp" }, remark = "��¼")
		ReturnStatus login(
				String uuid,
				String dvid,
				String token,
				String phone,
				String screen,
				double ver,
				@B2Param(oType = "OutStringVal", isOut = true) OutStrVal outDat,
				@B2Param(oType = "OutBoolVal", isOut = true) OutBoolVal outHasPvp);

		@B2Method(type = SERVER, params = {}, remark = "����")
		ReturnStatus tick();

		@B2Method(type = SERVER, params = { "portId", "newMz" }, remark = "��ͷ����")
		ReturnStatus changeDockMz(int portId, String newMz);

		@B2Method(type = SERVER, params = { "portId", "opid" }, remark = "������ͷ,0:����1:ȡ��")
		ReturnStatus abandonedPort(int portId, int opid);

		@B2Method(type = SERVER, params = {}, remark = "������λ")
		ReturnStatus advanceTitleOfNobility();

		@B2Method(type = SERVER, params = { "djid", "num" }, remark = "�������")
		ReturnStatus buyGood(int djid, int num);

		@B2Method(type = SERVER, params = { "ccid", "shipId" }, remark = "�Զ����ý���")
		ReturnStatus autoAssemblyShip(int ccid, int shipId);

		@B2Method(type = SERVER, params = { "ccid", "pos", "shipId", "num" }, remark = "���ý���")
		ReturnStatus assemblyShip(int ccid, int pos, int shipId, int num);

		@B2Method(type = SERVER, params = { "ccid" }, remark = "��ս���")
		ReturnStatus clearAssemblyShip(int ccid);

		@B2Method(type = SERVER, params = { "dockId" }, remark = "��������")
		ReturnStatus transportSilver(int dockId);

		@B2Method(type = SERVER, params = { "captainId", "bSwitch" }, remark = "�Զ�����")
		ReturnStatus autoFillShip(int captainId, boolean bSwitch);

		@B2Method(type = SERVER, params = { "escapeRatio" }, remark = "��������")
		ReturnStatus setEscapeRatio(double escapeRatio);

		// 0:���� 1:����������, 2:���ø�����1 3:���ø�����2
		@B2Method(type = SERVER, params = { "ccid", "attr", "opid" }, remark = "�޸Ľ�������")
		ReturnStatus changeCaptainAttribute(int ccid, String attr, int opid);

		@B2Method(type = SERVER, params = { "ccid", "force" }, remark = "�ɼ��鱦")
		ReturnStatus collectionJewelry(int ccid, boolean force);

		@B2Method(type = SERVER, params = { "dockId" }, remark = "�ղ���ͷ")
		ReturnStatus collectDock(int dockId);

		@B2Method(type = SERVER, params = { "dockId", "toPortId", "useGold" }, remark = "�ۿ�Ǩ��")
		ReturnStatus dockMove(int dockId, int toPortId, boolean useGold);

		@B2Method(type = SERVER, params = { "pid" }, remark = "��������")
		ReturnStatus dropProp(int pid);

		@B2Method(type = SERVER, params = { "str" }, remark = "����")
		ReturnStatus feedback(String str);

		@B2Method(type = SERVER, params = { "ccid" }, remark = "��������")
		ReturnStatus forgetFormation(int ccid);

		@B2Method(type = SERVER, params = { "ccid", "skid" }, remark = "��������")
		ReturnStatus forgetSkill(int ccid, int skid);

		@B2Method(type = SERVER, params = { "step" }, remark = "���ֲ���")
		ReturnStatus newbie(int step);

		@B2Method(type = SERVER, params = { "lineId", "type", "djid" }, remark = "0:��� 1:����")
		ReturnStatus lineSpeed(int lineId, int type, int djid);

		@B2Method(type = SERVER, params = { "type" }, remark = "���� 1:(67,68,69,71), 2:һ�������� , 3:5��������")
		ReturnStatus payTribute(int type);

		@B2Method(type = SERVER, params = { "userTaskId" }, remark = "��ȡ������")
		ReturnStatus rwReward(int userTaskId);

		@B2Method(type = SERVER, params = { "dockId", "page", "num" }, remark = "��ȡ��ͷ")
		ReturnStatus getDock(int dockId, int page, int num);

		@B2Method(type = SERVER, params = { "jcid", "num" }, remark = "ǿ������")
		ReturnStatus strengthenShip(int jcid, int num);

		@B2Method(type = SERVER, params = { "mz", "outUnions" }, remark = "���ҹ���")
		ReturnStatus unionSearch(String mz,
				@B2Param(oType = "Unions", isOut = true) Unions outUnions);

		@B2Method(type = SERVER, params = { "unionId" }, remark = "������Ϣ")
		ReturnStatus unionInfo(int unionId);

		@B2Method(type = SERVER, params = { "outUnion" }, remark = "���빫��")
		ReturnStatus unionEnter(
				@B2Param(oType = "UnionItem", isOut = true) UnionItem outUnion);

		@B2Method(type = SERVER, params = { "mz", "shortMz" }, remark = "��������")
		ReturnStatus unionCreate(String mz, String shortMz);

		@B2Method(type = SERVER, params = { "reqId" }, remark = "�������")
		ReturnStatus unionAgree(int reqId);

		@B2Method(type = SERVER, params = { "reqId" }, remark = "�ܾ�����")
		ReturnStatus unionRefuse(int reqId);

		@B2Method(type = SERVER, params = {}, remark = "��ɢ����")
		ReturnStatus unionDissolution();

		@B2Method(type = SERVER, params = { "str" }, remark = "�޸Ĺ�������")
		ReturnStatus unionUpdate(String str);

		@B2Method(type = SERVER, params = { "mid" }, remark = "�߳���Ա")
		ReturnStatus unionTakeout(int mid);

		@B2Method(type = SERVER, params = { "unionId" }, remark = "��������")
		ReturnStatus unionRequest(int unionId);

		@B2Method(type = SERVER, params = { "title", "str" }, remark = "Ⱥ���ʼ�")
		ReturnStatus unionSendMail(String title, String str);

		@B2Method(type = SERVER, params = { "jzid", "building" }, remark = "���Ὠ������")
		ReturnStatus unionUpLevel(
				int jzid,
				@B2Param(oType = "UnionBuilding", isOut = true) UnionBuilding outBuilding);

		@B2Method(type = SERVER, params = {}, remark = "�˳�����")
		ReturnStatus unionLeave();

		@B2Method(type = SERVER, params = { "yhid", "jobId", "outMember" }, remark = "����ְλ")
		ReturnStatus unionAppointed(
				int yhid,
				int jobId,
				@B2Param(oType = "UnionMember", isOut = true) UnionMember outMember);

		@B2Method(type = SERVER, params = { "gold", "outMember" }, remark = "�������")
		ReturnStatus unionDonation(
				int gold,
				@B2Param(oType = "UnionMember", isOut = true) UnionMember outMember);

		@B2Method(type = SERVER, params = { "page", "size", "outMembers" }, remark = "����ļ���嵥")
		ReturnStatus unionDonations(
				int page,
				int size,
				@B2Param(oType = "UnionMembers", isOut = true) UnionMembers outMembers);

		@B2Method(type = SERVER, params = { "page", "size", "outMembers" }, remark = "�����Ա")
		ReturnStatus getUnionMembers(
				int page,
				int size,
				@B2Param(oType = "UnionMembers", isOut = true) UnionMembers outMembers);

		@B2Method(type = SERVER, params = { "page", "size", "outReqs" }, remark = "��������嵥")
		ReturnStatus getUnionReqs(int page, int size,
				@B2Param(oType = "UnionReqs", isOut = true) UnionReqs outReqs);

		@B2Method(type = SERVER, params = { "outBuilding" }, remark = "���Ὠ��")
		ReturnStatus unionBuilding(
				@B2Param(oType = "UnionBuildings", isOut = true) UnionBuildings outBuilding);

		@B2Method(type = SERVER, params = { "ccid", "userDjid" }, remark = "ʹ�õ���")
		ReturnStatus useProp(int ccid, int userDjid);

		@B2Method(type = SERVER, params = { "receiverId", "receiverMz",
				"title", "content" }, remark = "�����ʼ�")
		ReturnStatus sendMail(int receiverId, String receiverMz, String title,
				String content);

		@B2Method(type = SERVER, params = { "type", "page", "size", "mails",
				"outType", "outUnReadNum", "outPageCount" }, remark = "�ʼ��б�")
		ReturnStatus mailListing(
				int type,
				int page,
				int size,
				@B2Param(oType = "Mails", isOut = true) Mails mails,
				@B2Param(oType = "OutIntVal", isOut = true) OutIntVal outType,
				@B2Param(oType = "OutIntVal", isOut = true) OutIntVal outUnReadNum,
				@B2Param(oType = "OutIntVal", isOut = true) OutIntVal outPageCount);

		@B2Method(type = SERVER, params = { "mails" }, remark = "Pvpδ���ʼ��б�")
		ReturnStatus pvpUnReadMails(
				@B2Param(oType = "Mails", isOut = true) Mails mails);

		@B2Method(type = SERVER, params = { "mailId", "outMail" }, remark = "�Ķ��ʼ�")
		ReturnStatus getMail(int mailId,
				@B2Param(oType = "MailItem", isOut = true) MailItem outMail);

		@B2Method(type = SERVER, params = { "mailIds" }, remark = "ɾ���ʼ�")
		ReturnStatus delMails(@B2Param(oType = "Integer") List<Integer> mailIds);

		@B2Method(type = SERVER, params = {}, remark = "����̽�մ���")
		ReturnStatus upTimesExplore();

		@B2Method(type = SERVER, params = { "ccid", "opid" }, remark = "ѵ������")
		ReturnStatus trainingCaptain(int ccid, int opid);

		@B2Method(type = SERVER, params = { "dockId" }, remark = "������ͷ")
		ReturnStatus spaceExpansion(int dockId);

		@B2Method(type = SERVER, params = { "userEquipId" }, remark = "����װ��")
		ReturnStatus sellEquip(int userEquipId);

		@B2Method(type = SERVER, params = { "white", "green", "blue", "violet" }, remark = "һ������װ��, Ʒ��,0:��ɫ,1:��ɫ,2:��ɫ,3��ɫ")
		ReturnStatus aKeySellEquip(boolean white, boolean green, boolean blue,
				boolean violet);

		@B2Method(type = SERVER, params = { "captainId", "isWear" }, remark = "һ��װ��. isWearc ����/ж��")
		ReturnStatus aKeyWear(int captainId, boolean isWear);

		@B2Method(type = SERVER, params = { "ccid", "outAttr" }, remark = "��������")
		ReturnStatus renewCaptainAttr(int ccid,
				@B2Param(oType = "RenewAttr", isOut = true) RenewAttr outAttr);

		@B2Method(type = SERVER, params = { "ccid", "useGold" }, remark = "���潢�����޽��")
		ReturnStatus comfirmRenewCaptainAttr(int ccid, boolean useGold);

		@B2Method(type = SERVER, params = { "ccid", "newmz" }, remark = "��������")
		ReturnStatus renameCaptain(int ccid, String newmz);

		@B2Method(type = SERVER, params = { "userEquipId", "useGold" }, remark = "װ������")
		ReturnStatus refineEquipage(int useEquipId, boolean useGold);

		@B2Method(type = SERVER, params = { "actId" }, remark = "����")
		ReturnStatus receiveGift(int actId);

		@B2Method(type = SERVER, params = {}, remark = "VIP���")
		ReturnStatus receiveVIPGift();

		@B2Method(type = SERVER, params = { "dockId" }, remark = "������ͷ")
		ReturnStatus findDock(int dockId);

		@B2Method(type = SERVER, params = { "isSandbox", "pid", "aid",
				"receipt", "num" }, remark = "app store��ֵ")
		ReturnStatus paymentCharge(boolean isSandbox, String pid, String aid,
				String receipt, int num);

		@B2Method(type = SERVER, params = { "routeId" }, remark = "���߷���")
		ReturnStatus marineHomeward(int routeId);

		@B2Method(type = SERVER, params = { "clear", "fids" }, remark = "ɾ���ղؼ�")
		ReturnStatus delFavorite(boolean clear,
				@B2Param(oType = "Integer") List<Integer> fids);

		@B2Method(type = SERVER, params = { "ccid" }, remark = "�ɼ���ȴ")
		ReturnStatus cooldownColleaction(int ccid);

		@B2Method(type = SERVER, params = { "ccid" }, remark = "��ʹ���")
		ReturnStatus fireCaptain(int ccid);

		@B2Method(type = SERVER, params = { "type", "page", "size" }, remark = "���а� // 0:��λ 1:���� 2:�Ƹ� 3:���� 4:����")
		void getBillboard(int type, int page, int size);

		@B2Method(type = SERVER, params = { "gkid" }, remark = "ֳ����")
		void checkColony(int gkid);

		@B2Method(type = SERVER, params = { "gkid", "useGold" }, remark = "ֳ��")
		ReturnStatus colony(int gkid, boolean useGold);

		@B2Method(type = SERVER, params = {}, remark = "��ǰ�ۿڶ�Ӧ�����嵥")
		ReturnStatus getPiratesByCurrentPortId();

		@B2Method(type = SERVER, params = { "portId" }, remark = "������Ӧ��ͷ�嵥")
		ReturnStatus getPirateDocksByPortId(int portId);

		@B2Method(type = SERVER, params = { "ccid" }, remark = "ȡ�ý�����Ϣ")
		ReturnStatus getCaptainById(int ccid);

		@B2Method(type = SERVER, params = { "pirateDockId", "memberNum", "type" }, remark = "��ӽ˺���")
		ReturnStatus beginPirateGroup(int pirateDockId, int memberNum, int type);

		@B2Method(type = SERVER, params = { "groupId", "outTime" }, remark = "ȡ����ӽ˺���")
		ReturnStatus endPirateGroup(int groupId,
				@B2Param(oType = "OutIntVal", isOut = true) OutIntVal outTime);

		@B2Method(type = SERVER, params = { "dockId" }, remark = "���򻤶�")
		ReturnStatus buyShield(int dockId);

		@B2Method(type = SERVER, params = {}, remark = "�˳���Ϸ")
		void quit();

		@B2Method(type = SERVER, params = { "gid", "rmb" }, remark = "25PP������ֵ����")
		ReturnStatus createOrder25PP(long gid, double rmb);

		@B2Method(type = SERVER, params = { "isOK", "page", "size" }, remark = "ȡ��25PP����")
		void getOrders(boolean isOK, int page, int size);

		@B2Method(type = SERVER, params = { "gid", "rmb" }, remark = "91������ֵ����")
		ReturnStatus createOrder91(long gid, double rmb);

		@B2Method(type = SERVER, params = { "gid", "rmb" }, remark = "С�״�����ֵ����")
		ReturnStatus createOrderMi(long gid, double rmb);

		@B2Method(type = SERVER, params = { "chnMz", "gid", "rmb" }, remark = "[UC/D��/�ƶ�]������ֵ����")
		ReturnStatus createOrder(String chnMz, long gid, double rmb);

		@B2Method(type = SERVER, params = {}, remark = "��øۿڵ�״̬")
		ReturnStatus getPortsStat();

		@B2Method(type = SERVER, params = {}, remark = "�û���װ��")
		ReturnStatus getUserEquips();

		@B2Method(type = SERVER, params = {}, remark = "�û��ĵ���")
		ReturnStatus getUserProps();

		@B2Method(type = SERVER, params = { "portId2", "captainIds",
				"outSilver", "outTm" }, remark = "�����������")
		ReturnStatus marineDepartCalculate(
				int portId2,
				@B2Param(oType = "Integer") List<Integer> captainIds,
				@B2Param(oType = "OutIntVal", isOut = true) OutIntVal outSilver,
				@B2Param(oType = "OutLongVal", isOut = true) OutLongVal outTm);

		@B2Method(type = SERVER, params = { "dockId2", "cmd", "captainIds",
				"silver" }, remark = "����")
		ReturnStatus marineDepart(int dockId2, int cmd,
				@B2Param(oType = "Integer") List<Integer> captainIds, int silver);

		@B2Method(type = SERVER, params = { "type", "force", "useGold",
				"outType", "outGem" }, remark = "�ڱ�ʯ(�̱�ʯ,����ʯ,�ϱ�ʯ)")
		ReturnStatus excavateGem(int type, boolean force, boolean useGold,
				@B2Param(oType = "OutIntVal", isOut = true) OutIntVal outType,
				@B2Param(oType = "OutIntVal", isOut = true) OutIntVal outGem);

		@B2Method(type = SERVER, params = { "yhid2", "mz2", "msg" }, remark = "˽��")
		ReturnStatus privateChat(int yhid2, String mz2, String msg);

		@B2Method(type = SERVER, params = { "msg" }, remark = "����")
		ReturnStatus publicChat(String msg);

		@B2Method(type = SERVER, params = { "groupId", "msg" }, remark = "�������")
		ReturnStatus inviteGroup(int groupId, String msg);

		@B2Method(type = SERVER, params = { "groupId" }, remark = "�������")
		ReturnStatus joinInviteGroup(int groupId);

		@B2Method(type = SERVER, params = { "msg" }, remark = "��������")
		ReturnStatus unionChat(String msg);

		@B2Method(type = SERVER, params = { "msg" }, remark = "����")
		ReturnStatus laba(String msg);

		@B2Method(type = SERVER, params = { "zbid", "fw", "useGold", "outRate",
				"outMainRate", "outGold", "outForceGold" }, remark = "ǿ������")
		ReturnStatus getStrengthenEquipage(
				int zbid,
				int fw,
				@B2Param(oType = "OutIntVal", isOut = true) OutIntVal outZbid,
				@B2Param(oType = "OutIntVal", isOut = true) OutIntVal outRate,
				@B2Param(oType = "OutIntVal", isOut = true) OutIntVal outMainRate,
				@B2Param(oType = "OutIntVal", isOut = true) OutIntVal outGem,
				@B2Param(oType = "OutIntVal", isOut = true) OutIntVal outForceGold);

		@B2Method(type = SERVER, params = { "zbid", "fw", "useGold",
				"outSuccess" }, remark = "ǿ��װ��")
		ReturnStatus strengthenEquipage(
				int zbid,
				int fw,
				boolean useGold,
				@B2Param(oType = "OutBoolVal", isOut = true) OutBoolVal outSuccess);

		@B2Method(type = SERVER, params = { "useGold", "djid", "outTm" }, remark = "��ȴ��������")
		ReturnStatus cooldownBuilding(boolean useGold, int djid,
				@B2Param(oType = "OutLongVal", isOut = true) OutLongVal outTm);

		@B2Method(type = SERVER, params = { "useGold", "djid", "outTm" }, remark = "��ȴ�Ƽ�����")
		ReturnStatus cooldownTech(boolean useGold, int djid,
				@B2Param(oType = "OutLongVal", isOut = true) OutLongVal outTm);

		@B2Method(type = SERVER, params = { "useGold", "djid", "outTm" }, remark = "��ȴ��������")
		ReturnStatus cooldownFacility(boolean useGold, int djid,
				@B2Param(oType = "OutLongVal", isOut = true) OutLongVal outTm);

		@B2Method(type = SERVER, params = { "buidingId", "useGold", "outTm",
				"outPredisp" }, remark = "����������")
		ReturnStatus upOrDownBuilding(
				int buidingId,
				boolean useGold,
				@B2Param(oType = "OutLongVal", isOut = true) OutLongVal outTm,
				@B2Param(oType = "OutStrListVal", isOut = true) OutStrListVal outPredisp);

		@B2Method(type = SERVER, params = { "teachId", "useGold", "outTm",
				"outPredisp" }, remark = "�Ƽ�����")
		ReturnStatus upTech(
				int teachId,
				boolean useGold,
				@B2Param(oType = "OutLongVal", isOut = true) OutLongVal outTm,
				@B2Param(oType = "OutStrListVal", isOut = true) OutStrListVal outPredisp);

		@B2Method(type = SERVER, params = { "productId", "num", "useGold",
				"outTm", "outPredisp" }, remark = "����")
		ReturnStatus productFacility(
				int productId,
				int num,
				boolean useGold,
				@B2Param(oType = "OutLongVal", isOut = true) OutLongVal outTm,
				@B2Param(oType = "OutStrListVal", isOut = true) OutStrListVal outPredisp);

		@B2Method(type = SERVER, params = { "captainId", "equipId", "isWear" }, remark = "����װ��")
		ReturnStatus wearEquip(int captainId, int equipId, boolean isWear);

		@B2Method(type = SERVER, params = { "captainType", "outCaptainId" }, remark = "��ļ����")
		ReturnStatus recruitCaptain(
				int captainType,
				@B2Param(oType = "OutIntVal", isOut = true) OutIntVal outCaptainId);

		@B2Method(type = SERVER, params = { "captainId", "type", "outEx",
				"outExid" }, remark = "����̽��")
		ReturnStatus createExplore(int captainId, int type,
				@B2Param(oType = "IdMzItems", isOut = true) IdMzItems outEx,
				@B2Param(oType = "OutIntVal", isOut = true) OutIntVal outExid);

		@B2Method(type = SERVER, params = { "exId", "txdid", "outEx", "outGem" }, remark = "ִ��̽��")
		ReturnStatus startExplore(int exId, int txdid,
				@B2Param(oType = "IdMzItems", isOut = true) IdMzItems outEx,
				@B2Param(oType = "OutIntVal", isOut = true) OutIntVal outGem);

		@B2Method(type = SERVER, params = { "exId", "outEx" }, remark = "ˢ��̽�յص�")
		ReturnStatus nextExploreIslands(int exId,
				@B2Param(oType = "IdMzItems", isOut = true) IdMzItems outEx);

		@B2Method(type = SERVER, params = {}, remark = "������߱���")
		ReturnStatus expPropsPack();

		@B2Method(type = SERVER, params = {}, remark = "����װ������")
		ReturnStatus expEquipPack();

		@B2Method(type = SERVER, params = {}, remark = "����ѵ��λ")
		ReturnStatus expTrainSeat();

		@B2Method(type = SERVER, params = { "gridId", "captainId" }, remark = "�����Ź���, ����")
		ReturnStatus captainGrid(int gridId, int captainId);

		@B2Method(type = SERVER, params = { "gridId" }, remark = "����Ź���, ����")
		ReturnStatus buyGrid(int gridId);

		@B2Method(type = SERVER, params = { "outDiscount", "outHots",
				"outCaptains", "outBoxs", "outOthers" }, remark = "��Ʒ")
		ReturnStatus markets(
				@B2Param(oType = "OutDoubleVal", isOut = true) OutDoubleVal outDiscount,
				@B2Param(oType = "MarketItems", isOut = true) MarketItems outHots,
				@B2Param(oType = "MarketItems", isOut = true) MarketItems outCaptains,
				@B2Param(oType = "MarketItems", isOut = true) MarketItems outBoxs,
				@B2Param(oType = "MarketItems", isOut = true) MarketItems outOthers);

		@B2Method(type = SERVER, params = {}, remark = "����ղؼ�")
		ReturnStatus getFavorites();

		@B2Method(type = SERVER, params = { "num" }, remark = "����˽�����֤")
		ReturnStatus buyPrivateerLic(int num);

		@B2Method(type = SERVER, params = { "dockId", "num", "outReward" }, remark = "�Զ�ˢ����")
		ReturnStatus autoRefPirate(
				int dockId,
				int num,
				@B2Param(oType = "PirateReward", isOut = true) PirateReward outReward);

		@B2Method(type = SERVER, params = { "dockId" }, remark = "�л���ǰ��ͷ")
		ReturnStatus changeCurrentDock(int dockId);

		@B2Method(type = SERVER, params = { "dockId", "buildId" }, remark = "������Ϣ")
		ReturnStatus getBuildingInfo(int dockId, int buildId);

		@B2Method(type = SERVER, params = { "minVip", "outVips" }, remark = "vip��Ϣ")
		ReturnStatus vipInfo(int minVip,
				@B2Param(oType = "VipItems", isOut = true) VipItems outVips);

		@B2Method(type = SERVER, params = { "outTargert" }, remark = "Ѱ��Pvpս��")
		ReturnStatus findFightPvpTargert(
				@B2Param(oType = "FightPvpTargert", isOut = true) FightPvpTargert outTargert);

		@B2Method(type = SERVER, params = { "mtid2" }, remark = "��ʼս��(ս������)")
		ReturnStatus startBattle(int mtid2);

		@B2Method(type = SERVER, params = { "ccid", "ccid2", "x1", "y1", "x2",
				"y2" }, remark = "Ѱ��")
		ReturnStatus battleTargert(int ccid, int ccid2, int x1, int y1, int x2,
				int y2);

		@B2Method(type = SERVER, params = { "ccid", "ccid2", "x1", "y1", "x2",
				"y2", "jnid1", "jnid2", "zxid", "fjnid2", "berths" }, remark = "����(����1,����2,������,������,����,����������)")
		ReturnStatus battleAttack(int ccid, int ccid2, int x1, int y1, int x2,
				int y2, int jnid1, int jnid2, int zxid, int fjnid2,
				@B2Param(oType = "XBerth") List<XBerth> berths);

		@B2Method(type = SERVER, params = {}, remark = "����ս��")
		ReturnStatus endBattle();

		@B2Method(type = SERVER, params = { "isWatch" }, remark = "�ۿ�ս��")
		ReturnStatus watchBattle(boolean isWatch);

		@B2Method(type = SERVER, params = { "mtid", "outStr" }, remark = "�����ͷ")
		ReturnStatus investigate(int mtid,
				@B2Param(oType = "OutStrVal", isOut = true) OutStrVal outStr);

		@B2Method(type = SERVER, params = { "captainId", "jobId", "useGold" }, remark = "תְ")
		ReturnStatus changeOccupation(int captainId, int jobId, boolean useGold);

		@B2Method(type = SERVER, params = { "deviceToken" }, remark = "���deivceToken")
		ReturnStatus changeDeviceToken(String deviceToken);

		@B2Method(type = SERVER, params = { "uid", "outUser" }, remark = "��ȡָ���û�������Ϣ")
		ReturnStatus getBaseUserInfo(
				int uid,
				@B2Param(oType = "BaseUserInfo", isOut = true) BaseUserInfo outUser);

		@B2Method(type = SERVER, params = { "uc_sid", "isDebug", "outUcid" }, remark = "UC������ͨ��sessid��ȡucid")
		ReturnStatus getUcid(String uc_sid, boolean isDebug,
				@B2Param(oType = "OutStrVal", isOut = true) OutStrVal outUcid);

		@B2Method(type = SERVER, params = {}, remark = "ɾ��")
		ReturnStatus deleteMySelf();

		@B2Method(type = SERVER, params = {"buff", "outBuff"}, remark = "echo")
		ReturnStatus echo(OutStrVal buff, @B2Param(oType = "OutBytesVal", isOut = true) OutBytesVal outBuff);

		// //////////////////////////////////////////////////////////////////
		// �ͻ�����ʵ��
		@B2Method(type = CLIENT, params = { "s" }, remark = "pong")
		void pong(String s);

		@B2Method(type = CLIENT, params = { "dockId", "silver", "mailNum",
				"hasPvp" }, remark = "��Դ���")
		void pushResource(int dockId, int silver, int mailNum, boolean hasPvp);

		@B2Method(type = CLIENT, params = { "page", "count", "docks" }, remark = "������ͷ")
		void pushDock(int page, int count,
				@B2Param(oType = "Dock") List<Dock> docks);

		@B2Method(type = CLIENT, params = { "tips" }, remark = "������ʾ")
		void pushTips(@B2Param(oType = "TipItem") List<TipItem> tips);

		@B2Method(type = CLIENT, params = { "type", "bills" }, remark = "���а�")
		void pushBillboard(int type,
				@B2Param(oType = "BillItem") List<BillItem> bills);

		@B2Method(type = CLIENT, params = { "pirateStatus" }, remark = "���ŵĺ����ۿ�")
		void pushPortPirate(
				@B2Param(oType = "Integer") List<Integer> pirateStatus);

		@B2Method(type = CLIENT, params = { "silver", "succ", "msg" }, remark = "ֳ������")
		void pushCheckColony(int silver, int succ, String msg);

		@B2Method(type = CLIENT, params = { "dockId", "targertPortId", "opens",
				"closed" }, remark = "�ۿڿ��ŵĺ����嵥")
		void pushPiratesByPortId(int dockId, int targertPortId,
				@B2Param(oType = "Integer") List<Integer> opens,
				@B2Param(oType = "Integer") List<Integer> closed);

		@B2Method(type = CLIENT, params = { "portId", "docks" }, remark = "������Ӧ��ͷ�嵥")
		void pushPirateDocksByPortId(int portId,
				@B2Param(oType = "PirateDockItem") List<PirateDockItem> docks);

		@B2Method(type = CLIENT, params = { "groupId", "stat" }, remark = "�����������״̬, stat:0:������,1:����,2:�ر�")
		void pushPirateGroupState(int groupId, int stat);

		@B2Method(type = CLIENT, params = { "groupId", "yhid", "txid", "mz",
				"stat" }, remark = "��������/�˳����𺣵�����, stat:true��ʼ,false�˳�")
		void pushPirateGroupCaptionStat(int groupId, int yhid, int txid,
				String mz, boolean stat);

		@B2Method(type = CLIENT, params = { "succ", "msg", "orderId", "gold" }, remark = "���������ɹ�")
		void pushCreateOrder(int succ, String msg, int orderId, int gold);

		@B2Method(type = CLIENT, params = { "succ", "msg", "isOK", "orders",
				"page", "pageCount" }, remark = "ȡ�ö���, type:0 δ����, 1:����")
		void pushOrders(int succ, String msg, boolean isOK,
				@B2Param(oType = "OrderItem25PP") List<OrderItem25PP> orders,
				int page, int pageCount);

		@B2Method(type = CLIENT, params = { "stats" }, remark = "�ۿڵĿ���״̬")
		void pushPortsStat(
				@B2Param(oType = "PortStatItem") List<PortStatItem> stats);

		@B2Method(type = CLIENT, params = { "equips" }, remark = "�û���װ���嵥")
		void pushUserEquips(@B2Param(oType = "EquipItem") List<EquipItem> equips);

		@B2Method(type = CLIENT, params = { "props" }, remark = "�û��ĵ����嵥")
		void pushUserProps(@B2Param(oType = "PropItem") List<PropItem> equips);

		@B2Method(type = CLIENT, params = { "msg" }, remark = "������Ϣ")
		void pushChat(MsgItem msg);

		@B2Method(type = CLIENT, params = { "union" }, remark = "������Ϣ")
		void pushUnionInfo(UnionItem union);

		@B2Method(type = CLIENT, params = { "voyage" }, remark = "������Ϣ")
		void pushVoyage(VoyageItem voyage);

		@B2Method(type = CLIENT, params = { "favorites" }, remark = "����ղؼ�")
		void pushFavorites(
				@B2Param(oType = "FavoriteItem") List<FavoriteItem> favorites);

		@B2Method(type = CLIENT, params = { "captain" }, remark = "������Ϣ")
		void pushCaptain(CaptainItem captain);

		@B2Method(type = CLIENT, params = { "isBoss", "fleets" }, remark = "ս����ʼ����")
		void pushBattle(boolean isBoss,
				@B2Param(oType = "XFleet") List<XFleet> fleets);

		@B2Method(type = CLIENT, params = { "ccid", "ccid2" }, remark = "Ѱ��")
		ReturnStatus pushBattleTargert(int ccid, int ccid2);

		@B2Method(type = CLIENT, params = { "ccid", "ccid2", "jnid1", "jnid2",
				"zxid", "fjnid2", "berths" }, remark = "����(����1,����2,������,������,����,����������)")
		ReturnStatus pushBattleAttack(int ccid, int ccid2, int jnid1,
				int jnid2, int zxid, int fjnid2,
				@B2Param(oType = "XBerth") List<XBerth> berths);

		@B2Method(type = CLIENT, params = { "achievement", "ourLoss",
				"enmeyLoss", "str", "reward" }, remark = "ս����������,-5��ܣ�-4����,-3ʧ��,-2С��,-1:ϧ�� 0:ս������ 1:ս��ʤ�� (1:��ʤ,2:ʤ��,3:Сʤ,4:��ʤ,5:��ʤ)")
		ReturnStatus pushEndBattle(int achievement, int ourLoss, int enmeyLoss,
				String str, PirateReward reward);

		@B2Method(type = CLIENT, params = { "upgradeUrl", "scoreUrl" }, remark = "�ⲿ����Url��ַ")
		void pushOutUrls(String upgradeUrl, String scoreUrl);

		@B2Method(type = CLIENT, params = { "items" }, remark = "��Ҷһ��۸�")
		void pushExchangeGoldItems(
				@B2Param(oType = "ExchangeGoldItem") List<ExchangeGoldItem> items);

		@B2Method(type = CLIENT, params = { "isPvp" }, remark = "�Ƿ���pvp��Ϣ")
		void pushIsPvp(boolean isPvp);

		@B2Method(type = CLIENT, params = { "items" }, remark = "ƻ����Ʒ�۸�")
		void pushAppleItems(@B2Param(oType = "AppleItem") List<AppleItem> items);

		@B2Method(type = CLIENT, params = { "notices" }, remark = "����")
		ReturnStatus pushNotices(
				@B2Param(oType = "OutStrVal") OutStrVal outNotices);

		@B2Method(type = CLIENT, params = { "outHdid", "outPortId", "outMtid",
				"outMemberNum", "outGroupId", "outMsg" }, remark = "�����������")
		ReturnStatus pushInviteGroup(OutIntVal outHdid, OutIntVal outPortid,
				OutIntVal outMtid, OutIntVal outMemberNum,
				OutIntVal outGroupId, MsgItem outMsg);
	}

	public static void main(String[] args) throws Exception {
		Class<?> c = OceanG.class;
		boolean src = FileEx.exists("src");
		Bio2GJava.b2g(c, src);
		Bio2GCSharp.b2g(c, src);
	}

}
